Graph functional dependency checking

ABSTRACT

A computer implemented method for detecting errors in data includes obtaining one or more graph functional dependency (GFD) rules comprising a set of GFD rules, obtaining a set of GFDs representative of the data, building a canonical graph for the GFD rules, and determining that one or more GFD of the set of GFDs conflict based on the set of GFD rules and the canonical graph and, based thereon, determining an error in the set of GFDs.

TECHNICAL FIELD

The present disclosure is related to functional dependency checking, and in particular to graph functional dependency checking.

BACKGROUND

When receiving unstructured data, such as social media data or other data from non-relational database sources, there may be inconsistencies in the data, such as an object having a top speed, but the data reflecting two different top speeds for the same object, or a domain expert stating one thing as true, but a non-expert in the domain stating the same thing as false. In a relational database, functional dependencies are constraints between two sets of attributes in a relation. Conflicts may be found without much difficulty. However, unstructured data may be represented by graphs. It is difficult to determine inconsistencies or conflicts in data represented by graphs.

SUMMARY

Various examples are now described to introduce a selection of concepts in a simplified form that are further described below in the detailed description. The Summary is not intended to identify key or essential features of the claimed subject matter, nor is it intended to be used to limit the scope of the claimed subject matter.

According to one aspect of the present disclosure, a computer implemented method for detecting errors in data includes obtaining one or more graph functional dependency (GFD) rules comprising a set of GFD rules, obtaining a set of GFDs representative of the data, building a canonical graph for the GFD rules, and determining that one or more GFD of the set of GFDs conflict based on the set of GFD rules and the canonical graph and, based thereon, determining an error in the set of GFDs.

Optionally, in any of the preceding aspects, a further implementation of the aspect includes wherein the canonical graph includes an empty graph and wherein a conflict comprises a literal assigned two distinct constants.

Optionally, in any of the preceding aspects, a further implementation of the aspect includes populating the empty graph by an Expand( ) operation prior to determining if any one of the GFDs conflicts iteratively for each rule.

Optionally, in any of the preceding aspects, a further implementation of the aspect includes wherein the canonical graph comprises a first graph pattern Q6 and a second graph pattern Q7, wherein the canonical graph includes two distinct copies of the first graph pattern.

Optionally, in any of the preceding aspects, a further implementation of the aspect includes wherein the set of GFD rules include a first rule: φ₇=Q₆ [x, y, z, w](Ø→x.A=0 ∧y.B=1), a second rule: φ₉=Q₆ [x](y.B=1→w.C=1), and third rule: φ₁₀=Q₇ [x](w.C=1→x.A=1), wherein x, y, z, and w are vertices, and A, B, and C are attribute names

Optionally, in any of the preceding aspects, a further implementation of the aspect includes creating work units for each graph pattern and graph pattern copy for each GFD rule, coordinating execution of the work units on multiple processors, sharing results from each processor in response to applying the rule associated with each work unit, and assigning remaining work units to processors in response to sharing results to the multiple processors.

Optionally, in any of the preceding aspects, a further implementation of the aspect includes creating a priority queue with the work units, processing the work units on different processors, and sharing changes with other processors.

Optionally, in any of the preceding aspects, a further implementation of the aspect includes receiving a new GFD rule and determining if the set of GFD rules implies the new GFD rule.

Optionally, in any of the preceding aspects, a further implementation of the aspect includes wherein determining if the set of GFD rules implies the new rule comprises enforcing GFDs on matches in the canonical graph one by one and terminating the method with true when either an equivalence relation is conflicting or when an implied attribute name is a part of the equivalence relation.

According to one aspect of the present disclosure, a device includes a memory storage comprising instructions and one or more processors in communication with the memory, wherein the one or more processors execute the instructions to obtain one or more graph functional dependency (GFD) rules comprising a set of GFD rules, obtain a set of GFDs representative of data, build a canonical graph for the GFD rules, determine that one or more GFD of the sets of GFDs conflicts based on the GFD rules and the canonical graph, and based thereon, determine an error in the set of GFDs.

Optionally, in any of the preceding aspects, a further implementation of the aspect includes wherein the canonical graph includes an empty graph and wherein the one or more processors execute the instructions to populate the empty graph by an Expand( ) operation prior to determining if any one of the GFDs conflicts iteratively for each rule, and wherein a conflict comprises a literal assigned two distinct constants.

Optionally, in any of the preceding aspects, a further implementation of the aspect includes wherein the canonical graph comprises a first graph pattern Q6 and a second graph pattern Q7, wherein the canonical graph includes two distinct copies of the first graph pattern, wherein the GFD rules include a first rule: φ₇=Q₆[x, y, z, w](Ø→x.A=0∧y.B=1), a second rule: φ₉=Q₆[x](y.B=1→w.C=1), and third rule: φ₁₀=Q₇[x](w.C=1→x.A=1), wherein x, y, z, and w are vertices, and A, B, and C are attribute names.

Optionally, in any of the preceding aspects, a further implementation of the aspect includes wherein the one or more processors execute the instructions to create work units for each graph pattern and graph pattern copy for each GFD rule, coordinate execution of the work units on multiple processors, share results from each processor in response to applying the rule associated with each work unit, and assign remaining work units in response to sharing results to the multiple processors.

Optionally, in any of the preceding aspects, a further implementation of the aspect includes wherein the one or more processors execute the instructions to upon determining the set of GFDs does not conflict, receive a new GFD rule and determine if the set of rules implies the new GFD rule.

Optionally, in any of the preceding aspects, a further implementation of the aspect includes wherein determining if the set of rules implies the new rule comprises enforcing GFDs on matches in the canonical graph one by one and terminating with true when either an equivalence relation is conflicting or when the implied attribute name is a part of the equivalence relation.

Optionally, in any of the preceding aspects, a further implementation of the aspect includes wherein the one or more processors execute the instructions to create a priority queue with work units, process the work units on different processors, and share changes with other processors.

According to one aspect of the present disclosure, a computer-readable media stores computer instructions for detecting errors in data, that when executed by one or more processors cause the one or more processors to perform operations comprising obtaining a set of GFDs representative of the data, building a canonical graph for the GFD rules, and determining that one or more GFD of the set of GFDs conflict based on the set of GFD rules and the canonical graph and, based thereon, determining an error in the set of GFDs.

Optionally, in any of the preceding aspects, a further implementation of the aspect includes wherein the canonical graph comprises a first graph pattern Q6 and a second graph pattern Q7, wherein the canonical graph includes two distinct copies of the first graph pattern, and wherein the GFD rules include a first rule: φ₇=Q₆[x, y, z, w](Ø→x.A=0∧y.B=1), a second rule: φ₉=Q₆[x](y.B=1→w.C=1), and third rule: φ₁₀=Q₇[x](w.C=1→x.A=1), wherein x, y, z, and w are vertices, and A, B, and C are attribute names.

Optionally, in any of the preceding aspects, a further implementation of the aspect includes wherein the operations further comprise creating work units for each graph pattern and copy for each GFD rule, coordinating execution of the work units on multiple processors, sharing results from each processor in response to applying the rule associated with each work unit, and assigning remaining work units in response to sharing results to the multiple processors.

Optionally, in any of the preceding aspects, a further implementation of the aspect includes wherein the operations further comprise creating a priority queue with the work units, processing the work units on different processors, and sharing changes with other processors.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a flowchart illustrating a computer implemented method for detecting errors in data represented by graphs according to an example embodiment.

FIG. 2 is a flowchart illustrating a computer implemented method of determining if the set of rules implies a new rule according to an example embodiment.

FIG. 3 is a flowchart illustrating a method of determining satisfiability of a set of graph functional dependencies (GFDs) utilizing parallel processing resources according to an example embodiment.

FIG. 4 is a flowchart illustrating method of implication checking for a set of GFDs utilizing parallel processing resources according to an example embodiment.

FIGS. 5A, 5B, 5C, and 5D are GFDs defined with patterns Q₁, Q₂, Q₃, and Q₄ respectively according to an example embodiment.

FIGS. 6A, 6B, 6C, 6D, and 6E are GFDs defined with distinct patterns Q₅, Q₆, Q₇, Q₈, and Q₉ respectively according to an example embodiment.

FIG. 7 is a flowchart illustrating a computer executable exact sequential algorithm, SeqSat, for determining satisfiability of a set of GFDs according to an example embodiment.

FIG. 8A is pseudocode representation of a parallel algorithm, ParSat, for determining satisfiability of a set of GFDs according to an example embodiment.

FIG. 8B is pseudocode representation of a procedure, HomMatch, used by ParSat for determining satisfiability of a set of GFDs according to an example embodiment.

FIG. 8C is pseudocode representation of a procedure CheckAttr, used by ParSat, for determining satisfiability of a set of GFDs according to an example embodiment.

FIG. 9 is a block diagram illustrating a parallel processing system for performing parallel satisfiability and implication checking according to an example embodiment.

FIG. 10 is an illustration of splitting a work unit into a list of subunits according to an example embodiment.

FIG. 11 is an illustration of a dependency graph used to determine an order of performing work units according to an example embodiment.

FIG. 12 is a block diagram illustrating circuitry for processing resources for implementing algorithms and performing methods according to example embodiments.

DETAILED DESCRIPTION

In the following description, reference is made to the accompanying drawings that form a part hereof, and in which is shown by way of illustration specific embodiments which may be practiced. These embodiments are described in sufficient detail to enable those skilled in the art to practice the invention, and it is to be understood that other embodiments may be utilized and that structural, logical and electrical changes may be made without departing from the scope of the present invention. The following description of example embodiments is, therefore, not to be taken in a limited sense, and the scope of the present invention is defined by the appended claims.

The functions or algorithms described herein may be implemented in software in one embodiment. The software may consist of computer executable instructions stored on computer readable media or computer readable storage device such as one or more non-transitory memories or other type of hardware based storage devices, either local or networked. Further, such functions correspond to modules, which may be software, hardware, firmware or any combination thereof. Multiple functions may be performed in one or more modules as desired, and the embodiments described are merely examples. The software may be executed on a digital signal processor, ASIC, microprocessor, or other type of processor operating on a computer system, such as a personal computer, server or other computer system, turning such computer system into a specifically programmed machine.

When receiving unstructured data, such as social media data or other data from non-relational database sources, there may be inconsistencies in the data, such as an object having a top speed, but the data reflecting two different top speeds for the same object, or a domain expert stating one thing as true, but a non-expert in the domain stating the same thing as false. In a relational database, functional dependencies are constraints between two sets of attributes in a relation. Conflicts may be found without much difficulty. However, unstructured data may be represented by graphs. It is difficult to determine inconsistencies or conflicts in data represented by graphs.

Several classes of graph dependencies have recently been proposed to extend functional dependencies (FDs) from relations to graphs, referred to as graph functional dependencies (GFDs). The need for GFDs is evident in inconsistency detection, knowledge acquisition, knowledge base enrichment, and spam detection, among other things.

There are two fundamental problems for GFDs. One is the satisfiability problem, to decide whether a set Σ of GFDs has a model, i.e., a nonempty graph that satisfies all GFDs in Σ. The other is the implication problem, to decide whether a GFD φ is entailed by a set Σ of GFDs, i.e., for any graph G, if G satisfies Σ then G satisfies φ. These are classical problems associated with any dependency class, known as the static analyses.

These problems, satisfiability and implication are coNP-complete and NP-complete, respectively. In various embodiments, errors in data, such as unstructured data, represented by GFDs are detected by using algorithms for detecting satisfiability and implication of the GFDs. Parallel algorithms for both are also provided.

The satisfiability analysis enables checking whether a set Σ of GFDs discovered from (possibly dirty) real-life graphs is “dirty” itself before it is used to detect errors and spam. The implication analysis eliminates redundant GFDs that are entailed by others. That is, the implication analysis provides us with an optimization strategy to speed up, e.g., error detection process.

No matter how important, these problems are hard for GFDs. For relational FDs, the satisfiability problem is trivial: any set of FDs can find a nonempty relation that satisfies the FDs. The implication problem is in linear time. In contrast, for GFDs, the satisfiability and implication problems are coNP-complete and NP-complete, respectively. GFDs on graphs are more complicated than FDs on relations. A GFD is a combination of a graph pattern Q, to identify entities in a graph, and an “attribute dependency” X→Y that is applied to the entities identified. Since graph pattern matching is NP-complete under the semantics of homomorphism, the static analyses of GFDs are inevitably intractable.

In one embodiment, a small model property: a set Σ of GFDs is satisfiable if and only if (iff) there exists a graph G such that G satisfies Σ and the size |G| of G is bounded by the size |Σ| of Σ. This allows inspecting graphs G of a bounded size as candidate models of E. Based on the small model property, a sequential (exact) algorithm referred to as SeqSat, is used to check GFD satisfiability.

A parallel algorithm ParSat, may also used to check GFD satisfiability for large sets of GFD, such a social media data. ParSat is parallel scalable relative to SeqSat: its parallel running time is in O(t(|Σ|)/p), where t(|Σ|) denotes the cost of SeqSat and p is the number of processors used. As a result, ParS at enables reduced running time when more processors are used. Hence it is feasible to scale with large sets of GFDs, Σ, by increasing p, despite the intractability of GFD satisfiability.

In a further embodiment, GFD implication checking is parallelized. A further small model property: to check whether a set Σ of GFDs implies another GFD φ, suffices to inspect graphs of size bounded by the sizes of φ and Σ, and enforce the GFDs of Σ on the small graphs. Based on this, a sequential exact algorithm SeqImp is used to check GFD implication. A ParImp algorithm is obtained by parallelizing SeqImp. ParImp is parallel scalable relative to SeqImp, allowing scaling with large sets Σ of GFDs.

Algorithms ParSat and ParImp use one or more techniques for parallel reasoning by using a combination of datapartitioned parallelism and pipelined parallelism for early termination of checking. Dynamic workload assignment and work unit splitting may be used to handle stragglers. A topological order on work units may be based on a dependency graph.

These algorithms provide tools for reasoning about GFDs, to validate data quality rules and optimize rule-based process for cleaning graph data, among other things.

A computer implemented method for detecting errors in data is first described, followed by a description of example GFDs and supporting information regarding sequential and parallel algorithms for determining satisfiability and implication to detecting errors in data represented by sets of graphs.

FIG. 1 is a flowchart illustrating a computer implemented method 100 for detecting errors in data represented by graphs, such as directed graphs. Method 100 begins by the computer obtaining one or more graph functional dependency (GFD) rules at operation 110 and obtaining a set of GFDs at operation 120 representative of the data. The rules may contain one or more constraints, such as a vertices only having one value, or a value in one vertices implying a value in another vertices. The rules may be represented by edges between verticies in graph theory.

At operation 130, a canonical graph (a graph having a notation that is common) is built for each GFD rule. One or more of the sets of GFDs is determined to conflict based on the GFD rules and the canonical graph at operation 140. Based on the determination that a conflict exists, operation 150 determines that an error exists in the set of GFDs.

Once an error is determined, it is known that the set of graphs cannot be used for precise queries or possibly other data mining operations. A different set may then be tried until a set without errors is found. That set may be used for queries and other operations that benefit from known error free data.

The canonical graph includes an empty graph in one embodiment. A conflict is determined to exist when a literal is assigned two distinct constants as described in further detail below. The empty graph is populated by an Expand( ) operation prior to determining if any one of the GFDs conflicts iteratively for each rule. In one embodiment, the canonical graph comprises a first graph pattern Q6 and a second graph pattern Q7, and also includes two distinct copies of the first graph pattern Q6.

The GFD rules in one embodiment, include a first rule: φ₇=Q₆[x, y, z, w](Ø→x.A=0∧y.B=1), a second rule: φ₉=Q₆[x] B=1→w.C=1), and third rule: φ₁₀=Q₇[x](w.C=1→x.A=1), wherein x, y, z, and w are vertices, and A, B, and C are attribute names.

In one embodiment, operation 160 includes receiving a new GFD rule, and operation 170 determines if the set of rules implies the new GFD rule. Operation 170 provides an efficient method of determining if the new GFD rule is satisfiable with the set of GFDs without having to start method 100 from the beginning.

FIG. 2 is a flowchart illustrating a method 200 of determining if the set of rules implies a new rule. At operation 210, GFDs are enforced on matches in the canonical graph one by one. The method is terminated at operation 220 with true in response to either an equivalence relation is conflicting or the implied attribute name is a part of the equivalence relation. The method is terminated with false at operation 230 when all GFDs are processed without terminating with true.

FIG. 3 is a flowchart illustrating a method 300 of determining satisfiability of a set of GFDs utilizing parallel processing resources. At operation 310, work units are created for each graph pattern for each GFD rule. A work unit is a set of candidate matches of a graph pattern to be checked as described in further detail below. Coordination of execution of each work unit on multiple processors is performed at operation 320. At operation 330, results from each processor are shared with other processors in response to applying the rule associated with each work unit. Remaining work units are assigned at operation 340 in response to sharing of the results to the multiple processors via operation 330.

FIG. 4 is a flowchart illustrating method 400 of implementing implication checking for a set of GFDs utilizing parallel processing resources. A priority queue with work units is created at operation 410, and the work units are processed at operation 420 on different processors. At operation 430, the results on each processor are shared with other processors.

The sequential and parallel algorithms for both satisfiability and implication are now described in further detail. Some definitions of terms notations are first provided. Assume two countably infinite alphabets Γ and θ for labels and attributes, respectively.

Graphs:

Directed graphs are defined as G=(V, E, L, F_(A)), where (1) V is a finite set of vertices, also referred to as nodes; (2) E⊆V×V, in which (v, v′) denotes an edge from node v to v′; (3) each node v∈V is labeled L(v)∈Γ; similarly L(e) is defined for edge e∈E; and (4) for each node v, F_(A)(v) is a tuple (A₁=a₁, . . . , A_(n)=a_(n)), where a is a constant, A_(i)∈θ is an attribute of v, written as v.A_(i)=a_(i), and A_(i)≠A_(j) if i≠j; the attributes carry content as in property graphs.

A graph (V′, E′, L′, F′_(A)) is a subgraph of (V, E, L, F_(A)) if V′⊆V, E′⊆E, for each node v∈V′, L′(v)=L(v) and F′_(A)(v)=F_(A)(v), and for each edge e∈E′, L′(e)=L(e).

Graph Patterns:

A graph pattern is a graph Q[x]=(V_(Q), E_(Q), L_(Q)), where (1) V_(Q) (resp. E_(Q)) is a finite set of pattern nodes (resp. edges); (2) L_(Q) is a function that assigns a label L_(Q)(u) (resp. L_(Q)(e)) to nodes u∈V_(Q) (resp. edges e∈E_(Q)); and (3) x is a list of distinct variables denoting nodes in V.

Labels L_(Q)(u) and L_(Q)(e) are taken from F and moreover, we allow L_(Q)(u) and L_(Q)(e) to be wildcard

Pattern Matching.

A match of pattern Q[x] in a graph G is a homomorphism h from Q to G such that (a) for each node u∈V_(Q), L_(Q)(u)=L(h(u)); and (b) for each edge e=(u, u′) in Q, e′=(h(u), h(u′)) is an edge in G and L_(Q)(e)=L(e′). In particular, L_(Q)(u)=L(h(u)) if L_(Q)(u) is ‘_’, i.e., wildcard indicates generic entities and can match any label in F.

The match is denoted as a vector h(x) if it is clear from the context, where h(x) consists of h(x) for each x∈x. Intuitively, x is a list of entities to be identified by Q, and h(x) is such an instantiation in G, one node for each entity.

Graph functional dependencies are referred to as GFDs, from syntax to semantics.

Syntax.

A GFD φ is a pair Q[x](X→Y) [1], where

Q[x] is a graph pattern, called the pattern of φ; and

X and Y are two (possibly empty) sets of literals of x.

A literal of x is either x.A=c or x.A=y. B, where x and y are variables in x (denoting nodes in Q), A and B are attributes in θ (not specified in Q), and c is a constant.

GFD φ specifies two constraints: (a) a topological constraint Q, and (b) an attribute dependency X→Y. Pattern Q specifies the scope of the GFD: it identifies subgraphs of G on which X→Y is enforced. As observed in [2], attribute dependencies X→Y subsume relational EGDs and CFDs, in which FDs are a special case. In particular, literals x.A=c carry constant bindings along the same lines as CFDs [16]. Following [1], we refer to Q[x](X→Y) as graph functional dependencies (GFDs).

Semantics.

For a match h(x) of Q in a graph G and a literal x.A=c of x, we say that h(x) satisfies the literal if there exists attribute A at the node v=h(x) and v.A=c; similarly for literal x.A=y.B. We denote by h(x)|=X if h(x) satisfies all the literals in X; similarly for h(x)|=Y.

h( x )|=X→Y if h( x )|=X implies h( x )|=Y.

A graph G satisfies GFD φ, denoted by G|=φ, if for all matches h(x) of Q in G, h(x)|=X→Y.

Intuitively, G|=φ if for each match h(x) identified by Q, the attributes of the entities in h(x) satisfy X→Y.

Example 1

Consider GFDs defined with patterns Q₁, Q₂, Q₃, and Q₄ shown in FIGS. 5A, 5B, 5C, and 5D respectively. These GFDs are able to catch semantic inconsistencies in real-life knowledge bases and social graphs. (1) GFD φ₁=Q₁[x, y](Ø→false). It states that for any place x 510, if x is located in (edge 512) another place y 515, then y should not be part of (edge 517) x. Here X is Ø, and Boolean constant false is a syntactic sugar for, e.g., x.A=c and x.A=d with distinct constants c and d. The GFD is defined with a cyclic pattern Q₁.

In DBpedia, Bamburi_airport is located in city Bamburi, but at the same time, Bamburi is put as part of Bamburi airport. Hence DBpedia does not satisfy φ₁, and the violation is caught by match h:x

Bamburi_airport and y

Bamburi of Q₁. The inconsistency is detected by φ₁.

(2) GFD φ₂=Q₂[x, y, z](Ø>y.val=z.val), where val is an attribute of y 520 and z 525. It says that the topSpeed is a functional property, i.e., an object x 530 has at most one top speed. Note that x is labeled wildcard ‘_’, and may denote, e.g., car, plane.

The GFD catches the following error in DBpedia: tanks are associated with two topSpeed values, 24.076 and 33.336.

(3) GFD φ₃=Q₃[x, y, z, w](x.c=y.c→z.val=w.val), where c is an attribute of person x 535 and person y 540 indicating country, and val is an attribute of z 545 and w 550 indicating value, in this case, country as shown in FIG. 5C. The GFD states if person x 535 and person y 540 are the president and vice president of the same country as indicated by edges 542 and 544, then x and y must have the same nationality. It catches the following inconsistency in DBpedia: the president and vice-president of Botswana have nationality Botswana and Tswana, respectively, while Tswana is ethnicity, not nationality

(4) GFD φ₄=Q₄[x, y, z₁, z₂, w₁, w₂](w₁.topic=w₁.topic→w₂.trust=“low”), where w₁ 560 and w₂ 565 carry attribute topic. It states that in a social network, if blogs w₁ 560 and w₂ 565 are posted by people x 570 and y 575, respectively, w₁ 560 and w₂ 565 give inconsistent accounts of the facts on the same topic, and if x is a domain expert z₁ 580 on the subject but y is not z₂ 582, then the account given by y 575 has low credibility. For instance, if a computer scientist x and a politician y gave two accounts of facts about the future of databases, then the comment from y can be discounted.

Graphs are considered in some embodiments that typically do not have a schema, as found in the real world. Hence a node v may not necessarily have a particular attribute. For a literal x.A=c in X, if h(x) has no attribute A, then h(x) trivially satisfies X→Y by the definition of h(x)|=X. In contrast, if x.A=c is in Y and h(x)|=Y, then h(x) must have attribute A by the definition of satisfaction; similarly for x.A=y.B.

In particular, if X is Ø, then h(x)|=X for any match h(x) of Q in G, and Y has to be enforced on h(x). In this case, if Y includes a literal x.A=c, then h(x) must carry attribute A. If Y=Ø, then Y is true, and φ is trivially satisfied.

The following notations may be used to describe the satisfiability problem for GFDs.

A model of a set of GFDs (E) is a (finite) graph G such that (a) G|=Σ, i.e., G satisfies all GFDs in Σ, and (b) for each GFD Q[x](X→Y) in Σ, there exists a match of Q in G.

Intuitively, if Σ has a model, then the GFDs in Σ are consistent, i.e., they do not conflict with each other, since all of them can be applied to the same graph. Σ is satisfiable iff Σ has a model. The satisfiability problem is to decide, given a set Σ of GFDs, whether Σ is satisfiable.

It is known that the problem is coNP-complete. However, there is no known way to develop a deterministic polynomial to check GFD satisfiability. In light of the absence of a deterministic polynomial, a small model property of the problem is established as described in further detail below. Based on the small model property, an exact algorithm for satisfiability checking is provided.

As opposed to relational FDs, a set Σ of GFDs may not be satisfiable. In fact, even if each GFD in Σ is satisfiable, Σ may not have a model, because the GFDs in Σ may interact with each other.

Example 2

Consider two GFDs defined with the same pattern Q₅ 600 depicted in FIG. 6A: φ₅=Q₅[x](Ø→x.A=0) and φ₆=Q₅[x](Ø→x.A=1), where Q₅ 600 has a single node or vertices x 602 labeled ‘_’. No nonempty graph G satisfies both φ₅ and φ₆. For if such G exists, φ_(s) and φ₆ require h(x).A to be 0 and 1, respectively, which is impossible; here h(x) is a match of x.

GFDs defined with distinct patterns may also interact with each other. Consider GFDs: φ₇=Q₆[x, y, z, w](Ø→x.A=0∧y.B=1) and φ₈=Q₇[x, y, z, w](y.B=1→x.A=1), with Q₆ 604 and Q₇ 630 shown in FIGS. 6B and 6C. Q₆ 604 has a node x 605 labeled “a” with edges 610, 614, 617 having a label “p” coupled to nodes y 620, z 622, and w 624 with attribute values of b, b and c respectively. Q₇ 630 has the same structure as Q₆ 604 with attribute values for y, z, w, of b, c, c. One can easily see that each of φ₇ and φ₈ has a model. However, there exists no model G for both φ₇ and φ₈. Indeed, if such G exists, then Q₆ 604 has a match h in G: h(x)

v, h(y)

v_(b), h(z)

v_(z), h(w)

v_(c). Hence φ₇ applies to the match and enforces v_(b).B=1. A match h′ of Q₇ in G can be given as h′(x)

v, h′(y)

v_(b), h′(z)

v_(c), h′(w)

v_(c), and φ₈ applies to the match since h′(x, y, z, w)|=h′(y).B=1. As a result, φ₇ and φ₈ require node v.A to be 1 and 0, respectively.

As shown by Example 2, while Q₇ 630 is not homomorphic to Q₆ 604 and vice versa, φ₇ and φ₈ can be enforced on the same node. Thus GFD satisfiability is nontrivial. It is shown coNP-hard by reduction from the complement of 3-colorability.

A Small Model Property

To find a model of a set Σ of GFDs, one cannot afford to enumerate all (infinitely many) finite graphs G and check whether G|=Σ. A small model property is established to reduce the search space.

A canonical graph G_(Σ) of Σ is defined to be (V_(Σ), E_(Σ), L_(Σ), F_(A) ^(Σ)), where V_(Σ) is the union of V_(i)'s, E_(Σ) is the union of E_(i)'s, and L_(Σ) is the union of L_(i)'s; but (d) F_(A) ^(Σ) is empty. It is assumed without loss of generality (w.l.o.g.) that patterns in Σ are pairwise disjoint, i.e., their nodes are denoted by distinct variables by renaming.

Intuitively, G_(Σ) is the union of all graph patterns in Σ, in which patterns from different GFDs are disjoint. A wildcard _ of Q in G_(Q) is kept and treated as a “normal” label such that only _ in a pattern can match _ in G.

Example 3

Consider a set Σ consisting of φ₇ and φ₈ of Example 2. Its canonical graph G_(Σ) is the graph by putting together Q₆ 604 and Q₇ 630 of FIGS. 6B and 6C, except that variables x, y, z, w in Q₇ are renamed as, e.g., x′, y′, z′, w′, respectively.

A population of G_(Σ) is a graph G=(V_(Σ), E_(Σ), L_(Σ), F_(A)), where F_(A) is a function that for each node v∈ V_(Σ), assigns F_(A)(y)=(A₁=a₁, . . . , A_(m)=a_(m)), a (finite) tuple of attributes from θ and their corresponding constant values.

Population G of G_(Σ) is said to be Σ-bounded if all attribute values in F_(A) have total size bounded by O(|Σ|), i.e., the values of all attributes in G are determined by Σ alone.

Intuitively, G and G_(Σ) have the same topological structure and labels, and G extends G_(Σ) with attributes and values. It is Σ-bounded if its size |G| is in O(|Σ|), including nodes, edges, attributes and all constant values in G.

Small model property. To check the satisfiability of Σ, it suffices to inspect Σ-bounded populations of the canonical graph G_(Σ) of Σ. A satisfiability checking algorithm is based on this small model property.

Theorem 1:

A set Σ of GFDs is satisfiable iff there exists a model G of Σ that is an Σ-bounded population of G.

Proof:

If there exists an Σ-bounded population of G_(Σ) that is a model of Σ, then obviously Σ is satisfiable. Conversely, if Σ has a model G, then there exists a homomorphism h from G_(Σ) to G. Employing h, a Σ-bounded population G′ of G_(Σ) is constructed. Attributes of G′ are populated by taking only relevant attributes from G, and by normalizing these attributes to make them Σ-bounded. The population preserves the constant values that appear in Σ and the equality on the attributes. G′|=Σ is shown by contradiction.

As an immediate corollary, an alternative proof is provided for the upper bound of the satisfiability problem for GFDs, instead of revising and using the chase.

Corollary 2:

The GFDs satisfiability problem is in coNP.

Proof:

An NP algorithm is used to check whether a set Σ of GFDs is not satisfiable, as follows: (a) guess an Σ-bounded attribute population G of Gs_(Σ), and a match h_(i) for each pattern Q_(i) of Σ in G; (b) check whether each h_(i) makes a match; if so, (c) check whether the matches violate any GFD in Σ in G. The correctness follows from Theorem 1. The algorithm is in NP since steps (b) and (c) are in PTIME (polynomial time). Thus the satisfiability problem is in coNP. G cannot be guessed as above and checked whether G|=Σ, since checking G|=Σ is already coNP-complete itself.

A Sequential Algorithm for Satisfiability

FIG. 7 is a flowchart illustrating a computer executable exact algorithm SeqSat 700 for determining satisfiability of a set of GFDs. Based on the small model property, SeqSat 700, takes as input a set Σ of GFDs, and returns true if and only if Σ is satisfiable as indicated at 710. The set of GFDs Σ is received as input at operation 720.

SeqSat 700 first, at operation 725 builds the canonical graph G_(Σ)=(V_(Σ), E_(Σ), L_(Σ), F_(A) ^(Σ)) of Σ. It then processes each GFD (rule) φ=Q[x](X→Y) in Σ and populates F_(A) ^(Σ) by invoking procedure Expand at operation 730. Expand finds matches h(x) of Q in Gs_(Σ), and checks whether h(x)|=X. If so, SeqSat 700 adds attributes x.A to FE and/or instantiates attributes x.A with constants for each literal x.A=c or x.A=y.B in Y, i.e., it “enforces” φ on the match h(x). If a conflict emerges as checked at operation 735, i.e., if there exists x.A such that x.A is assigned two distinct constants, SeqSat 700 terminates with false at operation 740. The process iterates as indicated by decision operation 750 until all GFDs in Σ are processed. If no conflict occurs, SeqSat 700 returns true at operation 755.

Algorithm SeqSat 700 supports early termination. It terminates with false at operation 740 as soon as a conflict is detected. Moreover, when a match h(x) is found, it expands F_(A) ^(Σ) by enforcing φ at match h(x), instead of waiting until all matches of Q are in place.

The correctness of SeqSat 700 is assured by the following: (a) it suffices to inspect populations of G_(Σ) by Theorem 1, and (b) attributes are populated by enforcing GFD φ on each match h(x) of Q, which is necessary for any population of G_(Σ) to satisfy Σ, by the semantics of GFD satisfaction.

Equivalence class. To speedup checking, SeqSat 700 represents F_(Σ) as an equivalence relation Eq. For each node x∈V_(Σ) and each attribute A of x, its equivalence class, denoted by [x.A]_(Eq), is a set of attributes y.B and constants c, such that x.A=y.B and x.A=c are enforced by GFDs in Σ (see below). One can easily verify that Eq is reflexive, symmetric and transitive.

Given a GFD φ=Q[x](X→Y) in Σ, Expand generates matches h(x) of Q in G_(Σ) along the same lines as VF2 [17] for subgraph isomorphism, except enforcing homomorphism rather than isomorphism. Then for each match h(x) found, Expand checks whether h(x)|=X. If so, it expands Eq by enforcing φ at h(x), with the following rules.

(Rule 1) If l is x.A=c, it checks whether [x.A]_(Eq) does not yet exist in Eq. If so, it adds [x.A]_(Eq) to Eq and c to [x.A]_(Eq). If [x.A]_(Eq) has a constant d≠c, it stops the process and SeqSat 700 terminates with false immediately.

(Rule 2) If l is x.A=y.B, it checks whether [x.A]_(Eq) and [y.B]_(Eq) are in Eq. If not, it adds the missing ones to Eq, and merges [x.A]_(Eq) and [y.B]_(Eq) into one. If the merged class includes distinct constants, SeqSat 700 terminates with false. That is, Expand generates new attributes, instantiates and equalizes attributes as required for the satisfiability of GFDs.

There is a complication when checking h(x)|=X. For a literal x.A=c in X, x.A may not yet exist in F_(A) ^(Σ) or is not instantiated (i.e., [x.A]_(Eq) does not include any constant). To cope with this, the following method may be used.

(a) Algorithm SeqSat 700 processes GFDs of the form Q[x](Ø→Y) first, if any in Σ. These add an initial batch of attributes.

(b) Expand maintains a list of matches h(x) and an inverted index with attribute h(x).A that appears in X, but either [h(x).A]_(Eq) does not exist or is not instantiated. When h(x).A is instantiated in a later stage, h(x) is efficiently retrieved by the inverted index using h(x).A, and is checked again.

(c) At the end of the process of SeqSat 700, some attribute x.A in Eq may still not be instantiated. The missing values do not affect the decision of SeqSat 700 on the satisfiability of Σ, since we can always complete F_(i)z, by assigning a distinct constant to each of such [x.A]_(Eq), without inflicting conflicts.

Example 4

Consider Σ={(φ₇, φ₉, φ₁₀}, where φ₇ is given in Example 2, φ₉=Q₆[x](y.B=1→w.C=1) and φ₁₀=Q₇[x](w.C=1→x.A=1), with Q₆ 604 and Q₇ 630 of FIGS. 6B and 6C. Its canonical graph G_(Σ) is similar to the one given in Example 3, with Q₇ 630 and two distinct copies of Q₆ 604 (from φ₇ and φ₉). Assume that SeqSat 700 checks ω₇, φ₁₀, φ₉ in this order.

(1) For φ₇, Expand finds a match of Q₆ in G_(Σ): h(x)

x, h(y)

y, h(z)

z, h(w)

>w. Since h(x)|=Ø, it adds [x.A]_(Eq) ([y.B]_(Eq)) to Eq and “0” (“1”) to [x.A]_(Eq) ([y.B]_(Eq)).

(2) When processing φ₁₀, Expand finds a match of Q₇ in G_(E): h′(x)

x, h′(y)

y, h′(z)

w, h′(w)

w. As [w.C]_(Eq) is not in Eq, it adds (h′(x), φ₁₀) to an inverted index with w.C.

(3) When processing φ₉, Expand finds a match of Q₆: h₁(x)

x, h₁(y)

y, h₁(z)

y, h₁(w)

w. It adds w.C to [y.B]_(Eq). This triggers re-checking of (h′(x), φ₁₀) with the inverted index. Now h′(x)|=w.C=1. Expand adds “1” to [x.A]_(Eq), to enforce φ₁₀. However, “0” is already in [x.A]_(Eq), a conflict. Hence SeqSat 700 stops and returns false.

Analysis.

Algorithm SeqSat 700 enforces GFDs of Σ by the semantics of GFDs. By Theorem 1, it returns true iff Σ has a model. One can verify that SeqSat 700 guarantees to converge at the same result no matter in what order the GFDs of Σ are applied, i.e., Church-Rosser, along the same lines as the characterization of GFD satisfiability. SeqSat 700 terminates early as soon as a conflict is spotted, and does not enumerate all matches by pruning to eliminate irrelevant matches early.

Algorithm SeqSat 700 is an exact algorithm. When Σ is large, SeqSat 700 may be costly due to the intractable nature of the satisfiability problem. A parallel algorithm, ParSat 800, shown in pseudocode in FIG. 8A, is a parallelized algorithm for determining satisfiability of a set of graphs. ParSat 800 works with two procedures, HomMatch 830 in FIG. 8B, and CheckAttr 850 in FIG. 8C, both of which are shown in pseudocode form and are described in detail below.

A characterization of parallel algorithms is first described, followed by description of the parallel algorithm ParSat 800 with performance guarantees.

In general, a parallel algorithm for a problem may not necessarily reduce sequential running time. An algorithm A_(p) for GFD satisfiability checking is parallel scalable relative to sequential algorithm SeqSat 700 if its running time can be expressed as:

${{T\left( {{\Sigma },p} \right)} = {O\mspace{11mu} \left( \frac{t\left( {\Sigma } \right)}{p} \right)}},$

where t(|Σ|) denotes the cost of SeqSat 700, and p is the number of processors employed by A_(p) for parallel computation.

Intuitively, a parallel scalable A_(p) linearly reduces the sequential cost of SeqSat 700 when p increases. By taking SeqSat 700 as a yardstick, A_(p) guarantees to run faster when adding more processors, and hence scale with large Σ.

ParSat 800 is parallel scalable relative to SeqSat 700. ParSat 800 makes use of both data partitioned parallelism and pipelined parallelism to speed up the process and facilitate interactions between GFDs. ParSat 800 provides dynamic workload balancing and work unit splitting, to handle stragglers, i.e., work units that take substantially longer than the others. ParSat 800 deduces a topological order on work units to reduce the impact of their interaction, based on a dependency graph, and retains the early termination property of SeqSat 700.

FIG. 9 is a block diagram illustrating a parallel processing system 900 for performing parallel satisfiability checking. ParSat 800 works with a coordinator S_(c) 910 and p workers (P₁, . . . , P_(p)) 915, 916, 917. A canonical graph G_(Σ) 920 is replicated at each worker 915, 916, 917, to reduce graph partition complication and communication costs. This is feasible since G_(Σ) 920 is much smaller than real-life data graphs 925 such as social networks, which have billions of nodes and trillions of edges.

Work units: Consider a GFD φ=Q[x](X→Y). To simplify the discussion, assume w.l.o.g. that Q is connected. A node x∈x is designated as a pivot of Q. A work unit w of Σ is a pair (Q[z], φ), where z is a node in G_(Σ) that matches the label of x. Intuitively, w indicates a set of candidate matches of Q to be checked.

A pivot x is used to explore the data locality of graph homomorphism: for any v in G_(E), if there exists a match h of Q in G_(Σ) such that h(x)=v, then h(x) consists of only nodes in the d_(Q)-neighbor of v. Here d_(Q) is the radius of Q at v, i.e., the longest shortest path from v to any node in Q. The d_(Q) neighbor of v includes all nodes and edges within d_(Q) hops of v. Thus each candidate match v of x determines a work unit, namely, the d_(Q)-neighbor of v, and the work units may be checked in parallel. Ideally, a pivot x is chosen that is selective, i.e., the pivot x, carries a label that does not occur often in G_(Σ); nonetheless, any node x in x can serve as a pivot.

When Q is disconnected, a work unit is (Q[z], φ), where z includes a pivot for each connected component of Q.

ParSat 800 works as follows, with lines of pseudocode numbered and referenced as lines 1-11 in FIG. 8A:

(1) Coordinator 910.

Given Σ 925, coordinator S_(c) 910 first (a) builds its canonical graph G_(Σ) 920 and replicates G_(Σ) at each worker (line 1), and (b) constructs a priority queue W 930 of all work units of Σ (line 2), following a topological order based on a dependency graph of Σ (see details below). Coordinator S_(c) 910 then activates each worker P_(i) with one work unit w from the front of W (line 3). In fact, work units can be assigned to worker in a small batch rather than a single w, to reduce the communication cost.

The coordinator 910 then interacts with workers and dynamically assigns workload, starting from the units of W with the highest priority (lines 4-10). A worker P_(i) may send two flags to S_(c): (a) f_(i) ^(c) if P_(i) detects a conflict when expanding equivalence relation Eq; and (b) f_(i) ^(d) if P_(i) is done with its work unit. If coordinator S_(c) 910 receives f_(i) ^(c) for any i∈[1, p], ParSat 800 terminates immediately with false (lines 5-6). If coordinator S_(c) 910 receives f_(i) ^(d), it assigns the next unit w′ in W to P_(i) and removes w′ from W (lines 7-8). The process iterates until either a conflict is detected, or W becomes empty, i.e., all work units have been processed. At this point algorithm ParSat 800 concludes that Σ is satisfiable and returns true (line 11).

A worker may split its unit w into a list L_(i) of sub-units if w is a straggler as illustrated at 1000 in FIG. 10. Upon receiving L_(i), coordinator S_(c) 910 adds L_(i) to the front of the priority queue W (lines 9-10). Putting these together, ParSat 800 implements data partitioned parallelism (by distributing work units of W), dynamic workload assignment, and early termination.

(2) Workers.

Each worker P_(i) 915 maintains the following: (a) local canonical graph G_(Σ) 920 in which an equivalence relation Eq_(i) represents its local F_(A) ^(Σ), and (b) a buffer ΔEq^(i) 940 that receives and stores updates to Eq_(i) from other workers. It processes its work unit w locally and interacts with coordinator S_(c) and other workers asynchronously as follows.

(a) Local Checking.

Upon receiving a work unit (Q[z], φ), P_(i) 915 conducts local checking in the d_(Q)-neighbor of z. This suffices to find matches h(x) of Q in G_(Σ) when the pivot x of Q is mapped to z, by the data locality of graph homomorphism.

Algorithm ParSat 800 implements Expand with two procedures: (i) HomMatch 830 finds matches h(x) of Q in G_(Σ) pivoted at z, and (ii) CheckAttr 850 expands Eq, by enforcing φ at match h(x) based on two expansion rules. ParSat 800 differs from Expand in the following. Each procedure has lines identified with consecutive line numbers referred to below.

The two procedures work in pipeline: as soon as a match h(x) is generated by HomMatch 830, CheckAttr 850 is triggered to check h(x) in a different thread, instead of waiting for all matches of Q to be found (lines 2-3 of HomMatch 830).

When enforcing φ at h(x) CheckAttr 850 computes Eq_(i) ⁽¹⁾=Eq_(i)∪ΔEq^(i), incorporating changes ΔEq^(i) from other workers, and CheckAttr 850 expands Eq_(i) ⁽¹⁾ to Eq_(i) ⁽²⁾ with φ.

If a conflict emerges, i.e., if some class [y.B]_(Eq) _(i) ₍₂₎ includes distinct constants, worker P_(i) sends flag f_(i) ^(c) to coordinator Sc and terminates the process (line 4). After all matches of Q pivoted at z are processed, P_(i) sends flag f_(i) ^(d) to S_(c) (line 9).

Like procedure Expand, CheckAttr 850 also maintains an inverted index on matches h(x) that need to be re-checked upon the availability of (instantiated) attributes needed.

(b) Interaction.

Worker P_(i) broadcasts its local changes ΔEq_(i) to other workers (line 5). It keeps receiving changes ΔEq^(i) from other processors and updates its local Eq_(i) by CheckAttr 850. The communication is asynchronous, i.e., there is no need to coordinate the exchange through Sc. This does not affect the correctness of ParSat 800 since equivalence relation Eq is monotonically expanding, and a conflict f_(i) ^(c) terminates the process no matter at which worker f_(i) ^(c) emerges.

Example 5

Recall Σ={φ₇, φ₉, φ₁₀} from Example 4. Its canonical graph G_(Σ) includes two copies of Q₆[x, y, z, w] and a copy of Q₇[x, y, z, w], in which variable x (designated as a pivot) in the three patterns is renamed as x₁, x₂, x₃, respectively; similarly for variables y, z, w.

ParSat 800 works with coordinator Sc and two workers P₁ and P₂. ParSat 800 first creates a priority queue W, where W has 9 work units w_(i)=(Q₆[x_(i)], φ₇), w_(3+i)=(Q₆[x_(i)], φ₉) and w_(6+i)=(Q₇[x_(i)], φ₁₀) in this order, for i∈[1, 3] (see Example 7). Then S_(c) sends w₁ to P₁ and w₂ to P₂. It then dynamically assigns the remaining units to P₁ and P₂ one by one following the order of W, upon receiving f_(j) ^(d) for j∈[1, 2].

Suppose that at a stage, worker P₁ has processed w₁, w₃ and w₅, and P₂ has handled w₂, w₄ and w₆. After P₁ is done with w₅, it sends f₁ ^(d) to S_(c) and gets a new work unit w₇. At this point, Eq₁ at P₁ includes [x₁.A]_(Eq) ₁ ={0, x₂.A, x₃.A} and [y₁.B]_(Eq) ₁ ={1, y₂.B, y₃.B, z₁.C, z₃.C, w₁.C, w₂.C, w₃.C}, after incorporating changes made at P₂. Now Expand finds a match h(x) h(x)

x₁, h(y)

y₂, h(z)

w₁ and h(w)

w₁ at P₁. Assume w.l.o.g. that ΔEq¹=Ø, i.e., no new changes are passed from P₂. By enforcing φ₁₀ at match h(x) CheckAttr 850 obtains ΔEq₁, which requires to add 1 to [x.A]_(Eq) ₁ . At this point, ParSat 800 finds a conflict: both 0 and 1 are in [x.A]_(Eq) _(i) . Hence CheckAttr 850 sends f₁ ^(c) to S_(c). When S_(c) receives f₁ ^(c), ParSat 800 returns false and terminates.

Parallel checking may be sped up in at least two ways, unit splitting, and by the use of a dependency graph.

Unit Splitting.

A work unit w=(Q[z],φ) assigned to a worker P_(i) may become a straggler and is “skewed”. ParSat 800 handles stragglers as follows. Recall that matching dominates the cost of w, and HomMatch 830 computes matches via backtracking like in VF2. When HomMatch 830 is triggered, it starts keeping track of the time τ spent on w. If τ exceeds a threshold TTL, it picks a set L_(i) of partial match h(y) of Q, i.e., y is a proper sub-list x. It treats (Q[y], φ) as a work unit, and sends L_(i) to S_(c) (lines 6-7). Worker P_(i) resets τ=0 and continues with the remaining work of w excluding those in L_(i) (line 8).

Coordinator S_(c) adds L_(i) to the front of W, and distributes the units to workers as usual. Upon receiving such (Q[w],φ), worker P_(j) resumes the checking from Q[w].

Example 6

Consider a work unit w=(Q[u₁₁], ), where φ=Q[x, y, z](X→Y), in which x is pivoted at u₁₁. Suppose that at one point, HomMatch 830 finds a match h(x, y, z): x

u₁₁, y

u₂₁ and z

u₃₂ as shown in FIG. 10 at 1000, and the time spent on w has exceeded TTL. Hence HomMatch 830 decides to split w. It creates a list L_(i) consisting of w_(j)=(Q[u₁₁, u₂ _(j) ],φ) for j∈[2, m], where w_(j) corresponds to a partial match h_(i)[x, y]: x

u₁₁ and y

u_(2i), and it does not include match for z; here partial matches h_(i) are found by backtracking one step. HomMatch 830 sends L_(i) to S_(c), restarts counter τ and continues to complete the processing of the current match h(x, y, z), to process, e.g., matches in which z ranges over u₃₂ and u₃₃.

Upon receiving L_(i), coordinator S_(c) 910 adds its units to the front of the priority queue and assigns them to available workers as usual. When, e.g., w_(j) is sent to a worker P_(k), P_(k) resumes the processing of w₁ starting from partial match h_(i)[x, y].

Dependency Graph.

A priority queue W of work units is built as indicated at line 2 of ParSat 800. A dependency graph G_(d)=(V,E), is constructed, where V is the set of work units, and (w₁,w₂) is a directed edge if (a) there exists an attribute x.A that appears in both Y₁ and X₂, where w₁=(Q₁[z₁],ϕ₁), w₂=(Q₂[x₂], ϕ₂), ϕ₁=Q₁[x ₁](X₁→Y₁), ϕ₂=Q₂[x ₂](X₂→Y₂), i.e., the antecedent X₂ of ϕ₂, may depend on the consequence Y₁ of ϕ₁; and (b) z₂ is within d_(Q) ₁ hops of z₁, i.e., the two pivots are close enough to interact.

ParSat 800 deduces a topological order from G_(d) and sorts W accordingly. Note that work units for GFDs Q[x](Ø→Y) are at the front of queue W, with the highest priority.

Example 7

For the 9 work units of Example 5, the dependency graph G_(d) is depicted in FIG. 11 at 1100. There exists an edge (w₁,w₄) since w₁ and w₄ are both pivoted at x₁, w₁ carries φ₇=Q₆[x, y, z, w](Ø→x.A=0∧y.B=1), w₄ carries φ₉=Q₆[w](y.B=1→w.C=1), and y.B is in both the consequence of φ₇ and the antecedent of φ₉; similarly for other edges in FIG. 11. In contrast, there is no edge between w₂ and w₄ since their pivots are not close, although they also carry φ₇ and φ₉, respectively. From G_(d) a topological order is deduced, to sort the work units of Example 5.

As another optimization strategy, ParSat 800 also extracts common sub-patterns that appear in multiple GFDs of Σ, finds matches of the sub-patterns at common pivots early, and reuses the matches when processing relevant GFDs. This is a common practice of multi-query optimization. To avoid the complexity of finding common sub-patterns, following, graph simulation is used to check whether a pattern Q₁ is homomorphic to a sub-pattern Q₂′ of Q₂. If Q₁ does not match Q₂′ by simulation, then Q₁ is not homomorphic to Q₂′. Since graph simulation is in O(|Q₁|·|Q₂′|) time, this method reduces the (possibly exponential) cost of checking homomorphism.

The correctness of ParS at 800 is warranted by Theorem 1 and the fact that equivalence relation Eq is monotonically increasing, similar to the inflational semantics of fixpoint computation. ParSat 800 parallelizes SeqSat 700, and is parallel scalable relative to SeqSat 700 by dynamic work unit assignment to balance workload, and work unit splitting to handle stragglers. One can verify by induction on the number of work units that the parallel runtime of ParSat 800 is in

${O\mspace{11mu} \left( \frac{t\left( {\Sigma } \right)}{p} \right)},$

where t(|Σ|) denotes the cost of SeqSat 700.

Implication checking may also be performed in a serial or parallel manner A set Σ of GFDs implies another GFD φ, denoted by Σ|=φ, if for all graphs G, if G|=Σ then G|=φ.

The implication problem for GFDs is to decide, given a finite set Σ of GFDs and another GFD φ, whether Σ|=φ. A small model property of the implication problem is used in one embodiment. Capitalizing on the small model property, a sequential exact algorithm SeqImp is used to perform implication checking. SeqImp may be parallelized to provide a parallel scalable algorithm ParImp.

A Small Model Property of GFD Implication

For traditional FDs over relations, the implication analysis takes linear time. When it comes to GFDs, however, the story is more complicated.

Example 8

Consider a set Σ={φ₁₁, φ₁₂} of GFDs, where φ₁₁=Q₈[x](Ø→x.A=1), φ₁₂=Q₉[x](x.A=1∧y.B=2→y.C=2), and pattern Q₈ 640 and Q₉ 650 are shown in FIG. 6D and FIG. 6E respectively. Consider φ₁₃=Q₇[x](z.B=2→z.C=2), with Q₇ in FIG. 6C. Then Σ|=φ₁₃. Indeed, for any graph G such that G|=Σ, and for any match h(x) of Q₇ in G, h(x) can be written as h(x)

u₁, h(y)

u₂, h(z)

u₃, h(w)

u₄, where u_(i) is in G for 1≤i≤4. If h(x)|=z.B=2, then by enforcing φ₁₁ and φ₁₂ on h(x), u₁.A=1, u₃.B=2 and u₃.C=2. Then h(x)|=z.C=2. Hence G|=φ₁₃. Note that φ₁₃ is not implied by each of φ₁₁ and φ₁₂ alone. However, when φ₁₁ and φ₁₂ are put together, they can deduce the consequence z.C=2 of φ₁₃.

Now consider φ₁₄=Q₇[x](x.A=0→z.C=2). Again, one can verify that Σ|=φ₁₄. This is because for any graph G and any match h(x) of Q₇ in G, if G|=Σ then h(x)|≠h(x).A=0, since φ₁₁ enforces h(x).A=0. That is, Q₇, x.A=0 and Σ are “inconsistent” when put together.

The implication problem may be derived by proving a small model property. This is more involved than its counterpart for satisfiability. Notations include the following.

Canonical Graphs.

Consider φ=Q[x](X→Y), where Q=(V_(Q), E_(Q), L_(Q)). The canonical graph of φ is G_(Q) ^(X)=(V_(Q), E_(Q), L_(Q), F_(A) ^(X)), where F_(A) ^(X) is defined as follows. For each node x∈V_(Q) (i.e., each x∈x), (a) if x.A=c is in X, then F_(A) ^(X) (x) has attribute A with x.A=c; (b) if x.A=y.B is in X, then F_(A) ^(X) (x) has attributes A and B such that x.A=y.B; and moreover, (c) F_(A) ^(X) is closed under the transitivity of equality, i.e., if x.A=y.B and y.B=z.C, then x.A=z.C; similarly if x.A=c and z.C=c, then x.A=z.C.

A wildcard _ of Q is kept in G_(Q) just like in G_(Σ). A (Σ,φ)-bounded population of G_(Q) ^(X) for canonical graph G_(Q) ^(X) of φ as a population of G_(Q) ^(X) such that its size is in O(|E|+|φ|) is defined. To check whether Σ|=φ, it suffices to populate the canonical graph G_(Q) ^(X).

Theorem 3:

For any set Σ of GFDs and GFD φ=Q[x](X→Y), Σ|=φ iff for all (Σ,φ)-bounded populations G of G_(Q) ^(X), either (a) G|≠Σ, or (b) G|=Σ and G|=φ.

Proof:

If Σ|=φ, then for all graphs G, if G|=Σ then G|=φ. These graphs include (Σ,φ)-bounded populations of G_(Q) ^(X). From this it follows that conditions (a) and (b) hold.

Conversely, assume that Σ|≠φ, i.e., there exists a graph G such that G|=Σ but G|≠φ. A (Σ, φ)-bounded population G′ of G_(Q) ^(X) is constructed such that G′|=Σ but G′|≠φ, violating conditions (a) and (b). The construction makes use of the “witness” of G|≠φ (the match of the pattern of in G that violates φ), and requires attribute value normalization as in the proof of Theorem 1, such that the total size of attributes in G are in O(|E|+|φ|) (see [15] for details).

Checking Implication.

To check whether Σ|=φ, Theorem 3 allows inspection of (Σ,φ)-bounded populations G of G_(Q) ^(X) only. However, all such small graphs are checked, exponentially many in total. To further reduce the search space, a corollary of Theorem 3 is proven.

Notations are provided. Recall equivalence class Eq representing F_(A) ^(Σ). Given a GFD ϕ=Q′[x′](X′→Y′) in Σ and a match h′ of Q′ in G_(Q) ^(X), Eq can be expanded by enforcing ϕ at h′ with the two rules.

A list H of such pairs (h′, ϕ) is referred to as a partial enforcement of Σ on G_(Q) ^(X). Eq_(H) is used to denote the expansion of Eq by H, by enforcing ϕ at h′ one by one.

Eq_(H) is conflicting if there exists [x.A]_(Eq) _(H) that includes distinct constants c and d. Intuitively, this means that the GFDs in H and Q, X are inconsistent.

Recall that φ=Q[x](X→Y). Y⊆Eq_(H) is written if for any literal u=v, v∈[u]_(Eq) _(H) where u=v is either x.A=c or x.A=y.B. That is, the literal can be deduced from the equivalence relation Eq_(H) via the transitivity of equality.

Corollary 4:

For any set Σ of GFDs and φ=Q[x](X→Y), Σ|=φ iff there exists a partial enforcement H of Σ on G_(Q) ^(X) such that either Eq_(H) is conflicting, or Y⊆Eq_(H). The two cases of Corollary 4 are illustrated in Example 8.

Proof:

If Σ|=φ, then such an H exists by Theorem 3, since each Eq_(H) is a (Σ,φ)-bounded population of G_(Q) ^(X).

Conversely, the following is shown by induction on the length of H. (1) If Eq_(H) is conflicting, then for all (Σ,φ)-bounded populations G of G_(Q) ^(X). G|≠Σ. (2) If Y⊆Eq_(H), then for all (Σ,φ)-bounded populations G of G_(Q) ^(X), if G|=Σ, then G|=φ. From this and Theorem 3 it follows that Σ|=φ.

Corollary 4 allows checking of Σ|=φ by selectively inspecting H, instead of enumerating all (Σ,φ)-bounded populations. Leveraging Corollary 4, the following is verified along the same lines as the proof of Corollary 2.

Corollary 5:

The GFD implication problem is in NP.

Sequential Algorithm for Implication

Capitalizing on Corollary 4, an exact sequential algorithm, SeqImp, for checking GFD implication is provided.

SeqImp takes as input a set Σ of GFDs and another GFD φ. It returns true if Σ|=φ, and false otherwise. Let φ=Q[x](X→Y). Similar to SeqSat 700 for satisfiability checking, algorithm SeqImp enforces GFDs of Σ on matches of Q in the canonical graph G_(Q) ^(X) one by one, and terminates as soon as Σ|=φ can be decided. It has the following subtle differences from SeqImp.

(a) In contrast to SeqSat 700 that starts with Eq initially empty, SeqImp uses Eq_(H) to represent partial enforcement, initialized as Eq_(X), the (nonempty) equivalence relation encoding F_(A) ^(X).

(b) SeqImp terminates with true when either (i) Eq_(H) is conflicting, or (ii) Y⊆Eq_(H). It terminates with false when all GFDs are processed, if neither conflict is detected nor Y

Eq_(H) in the entire process, concluding that Σ|≠φ.

Example 9

Recall Σ and φ₁₃ from Example 8. The canonical graph of φ₁₃ is Q₇ of FIG. 6C with F_(A) ^(X)={z.B=2}. Given these, SeqImp initializes Eq_(H) with [z.B]_(Eq)={2}. It expands Eq_(H) at (a) a match h(x) of Q₈: x₈

x and y₈

y, and (b) a match h′(x) of Q₉: x₉ 7

x, y₉

z, where x_(i) and y_(i) denote variables x and y, respectively, in Q_(i) for i∈[8, 9]. After enforcing φ₁₁ and φ₁₂ at h(x) and h′(x) respectively, it finds that (z.C=2)⊆Eq_(H), and terminates with true.

Now for φ₁₄. SeqImp starts with F_(A) ^(X′)={x.A=0}. After enforcing φ₁₁ at h(x) it adds “1” to [x.A]_(Eq), a conflict with [x.A]_(Eq)={0}. Hence SeqImp returns true and terminates.

Analysis.

The correctness of SeqImp follows from Corollary 4. Its complexity is dominated by generating matches of graph patterns in Σ, while Y⊆Eq_(H) and conflicts in Eq_(H) can be checked efficiently. In particular, the equivalence relation Eq_(H) can be computed in linear time with index. Moreover, one can verify that the length of Eq_(H) is bounded by |Q|·|Σ|.

Algorithm ParImp is a parallel scalable relative to SeqImp. Hence ParImp is capable of dealing with large set Σ of GFDs by adding processors as needed. ParImp works with a coordinator S_(c) and p workers (P₁, . . . , P_(p)), like ParS at 800. It first constructs the canonical graph G_(Q) ^(X) of φ, initializes Eq_(H) as Eq_(X), and replicates G_(Q) ^(X) and Eq_(H) at each worker.

Eq_(H) is expanded in parallel by distributing work units across p workers. A work unit (Q_(ϕ)[z],ϕ) is defined in the same way as previously described for GFDs ϕ=Q_(ϕ)[x _(ϕ)](X_(ϕ)→Y_(ϕ)) in Σ at pivots z in G_(Q) ^(X). The work units are organized in a priority queue W as before, based on a revised notion of dependency graph (see below). Algorithm ParImp dynamically assigns work units of W to workers, starting with the ones with the highest priority, in small batches. Workers process their assigned work units in parallel, broadcast their local Eq_(H) expansions to other workers, and send flags to S_(c). The process proceeds until (a) either at a partial enforcement H of G at some worker, Eq_(H) has conflict or Y⊆Eq_(H), or (b) all work units in W have been examined. The process returns true in case (a), and false in case (b), by Corollary 4.

ParImp employs the same dynamic workload assignment and unit splitting strategies of ParS at 800 to handle stragglers. ParImp also supports a combination of data partitioned parallelism and pipelined parallelism. It differs from ParSat 800 in the following.

(a) Dependency Graph.

ParImp deduces a topological order on W also based on the dependency graph of work units. The only difference is that a unit (Q_(ϕ)[z],ϕ) is associated with the highest priority if ϕ=Q_(ϕ)[x _(ϕ)](X_(ϕ)→Y_(ϕ)) and X subsumes X_(ϕ), i.e., each literal in X_(ϕ) can be deduced from Eq_(X).

(b) Early Termination.

Each worker P_(i) sends flag f_(i) ^(c) to coordinator if either (i) a conflict is detected in its local copy of Eq_(H), or (ii) Y⊆Eq_(H). Upon receiving f_(i) ^(c), algorithm ParImp terminates immediately with true, regardless of what P_(i) is.

Example 10

Assume a coordinator S_(c) and two workers P₁ and P₂. Given Σ and φ₁₃ of Example 9, ParImp creates the canonical graph of φ₁₃ and replicates it at P₁ and P₂, where Eq_((H,i)) at P_(i) is initialized as Eq_(H) for i∈[1, 2]. ParImp creates a priority queue W=[w₁=(Q₈[x], φ₁₁), w₂=(Q₉[x], φ₁₂)]. Then S_(c) sends w₁ to P₁ and w₂ to P₂. After P₁ enforces φ₁₁ on match h(x) given in Example 9, it sends changes ΔEq_((H,1))={[x.A]_(Eq) _((H,1)) ={1}, [

.B]_(Eq) _((H,1)) ={2}} to P₂. Worker P₂ enforces φ₁₂ on match h′(x) (Example 9). By incorporating changes from P₁, P₂ adds z.C to [

.B]_(Eq) _((H,2)) , which contains value 2. As a result, (z.C=2)⊆Eq_((H,2)). Hence it sends f₂ ^(c) to S_(c) and ParImp terminates with true.

Now consider φ₁₄ instead of φ₁₃. ParImp creates priority queue W=[w₁=(Q₉[x], φ1 ₂), w₂=(Q₈[x],φ₁₁)]. Note that W is different from the queue for φ₁₃, since the initial Eq_(H) includes [x.A]_(Eq) _(H) ={0}. Coordinator S_(c) sends w₁ to P₁ and w₂ to P₂. When P₂ enforces φ₁₁ on match h′(x) it adds “1” to [x.A]_(Eq) _((H,2)) , but “0” is already in [x.A]_(Eq) _((H,2)) . Thus P₂ sends f₂ ^(c) to S_(c) and ParImp stops with true.

Analysis.

The correctness of ParImp is assured by Corollary 4 and monotonic expansion of Eq_(H). ParImp is parallel scalable relative to SeqImp by dynamic workload balancing and unit splitting. Formally, one can show that ParSat 800 takes

$O\mspace{11mu} \left( \frac{t\mspace{11mu} \left( {{\Sigma },{\phi }} \right)}{p} \right)$

time with p workers, where t(|Σ|,|φ|) is the cost of SeqImp, by induction on the number of work units.

FIG. 12 is a block diagram illustrating circuitry for executing one or more of the sequential and parallel satisfiability and implication algorithms and for performing methods according to example embodiments. All components need not be used in various embodiments.

One example computing device in the form of a computer 1200 may include a processing unit 1202, memory 1203, removable storage 1210, and non-removable storage 1212. Although the example computing device is illustrated and described as computer 1200, the computing device may be in different forms in different embodiments. For example, the computing device may instead be a smartphone, a tablet, smartwatch, or other computing device including the same or similar elements as illustrated and described with regard to FIG. 12. Devices, such as smartphones, tablets, and smartwatches, are generally collectively referred to as mobile devices or user equipment. Further, although the various data storage elements are illustrated as part of the computer 1200, the storage may also or alternatively include cloud-based storage accessible via a network, such as the Internet or server-based storage.

Memory 1203 may include volatile memory 1214 and non-volatile memory 1208. Computer 1200 may include—or have access to a computing environment that includes—a variety of computer-readable media, such as volatile memory 1214 and non-volatile memory 1208, removable storage 1210 and non-removable storage 1212. Computer storage includes random access memory (RAM), read only memory (ROM), erasable programmable read-only memory (EPROM) or electrically erasable programmable read-only memory (EEPROM), flash memory or other memory technologies, compact disc read-only memory (CD ROM), Digital Versatile Disks (DVD) or other optical disk storage, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other medium capable of storing computer-readable instructions.

Computer 1200 may include or have access to a computing environment that includes input interface 1206, output interface 1204, and a communication interface 1216. Output interface 1204 may include a display device, such as a touchscreen, that also may serve as an input device. The input interface 1206 may include one or more of a touchscreen, touchpad, mouse, keyboard, camera, one or more device-specific buttons, one or more sensors integrated within or coupled via wired or wireless data connections to the computer 1200, and other input devices.

The computer may operate in a networked environment using a communication connection to connect to one or more remote computers, such as database servers. The remote computer may include a personal computer (PC), server, router, network PC, a peer device or other common DFD network switch, or the like. The communication connection may include a Local Area Network (LAN), a Wide Area Network (WAN), cellular, WiFi, Bluetooth, or other networks. According to one embodiment, the various components of computer 1200 are connected with a system bus 1220.

Computer-readable instructions stored on a computer-readable medium are executable by the processing unit 1202 of the computer 1200, such as a program 1218. The program 1218 in some embodiments comprises software that, when executed by the processing unit 1202, performs operations according to any of the embodiments included herein. A hard drive, CD-ROM, and RAM are some examples of articles including a non-transitory computer-readable medium such as a storage device. The terms computer-readable medium and storage device do not include carrier waves to the extent carrier waves are deemed too transitory. Storage can also include networked storage, such as a storage area network (SAN). Computer program 1218 may be used to cause processing unit 1202 to perform one or more methods or algorithms described herein.

Although a few embodiments have been described in detail above, other modifications are possible. For example, the logic flows depicted in the figures do not require the particular order shown, or sequential order, to achieve desirable results. Other steps may be provided, or steps may be eliminated, from the described flows, and other components may be added to, or removed from, the described systems. Other embodiments may be within the scope of the following claims. 

What is claimed is:
 1. A computer implemented method for detecting errors in data comprising: obtaining one or more graph functional dependency (GFD) rules comprising a set of GFD rules; obtaining a set of GFDs representative of the data; building a canonical graph for the GFD rules; and determining that one or more GFD of the set of GFDs conflict based on the set of GFD rules and the canonical graph and, based thereon, determining an error in the set of GFDs.
 2. The method of claim 1 wherein the canonical graph includes an empty graph and wherein a conflict comprises a literal assigned two distinct constants.
 3. The method of claim 2 and further comprising populating the empty graph by an Expand( ) operation prior to determining if any one of the GFDs conflicts iteratively for each rule.
 4. The method of claim 1 wherein the canonical graph comprises a first graph pattern Q6 and a second graph pattern Q7, wherein the canonical graph includes two distinct copies of the first graph pattern.
 5. The method of claim 4 wherein the set of GFD rules include a first rule: φ₇=Q₆ [x, y, z, w](Ø→x.A=0∧y.B=1), a second rule: φ₉=Q₆[x]B=1→w.C=1), and third rule: φ₁₀=Q₇[x](w.C=1→x.A=1), wherein x, y, z, and w are vertices, and A, B, and C are attribute names.
 6. The method of claim 4 and further comprising: creating work units for each graph pattern and graph pattern copy for each GFD rule; coordinating execution of the work units on multiple processors; sharing results from each processor in response to applying the rule associated with each work unit; and assigning remaining work units to processors in response to sharing results to the multiple processors.
 7. The method of claim 6 and further comprising: creating a priority queue with the work units; processing the work units on different processors; and sharing changes with other processors.
 8. The method of claim 1 and further comprising: receiving a new GFD rule; and determining if the set of GFD rules implies the new GFD rule.
 9. The method of claim 8 wherein determining if the set of GFD rules implies the new rule comprises: enforcing GFDs on matches in the canonical graph one by one; and terminating the method with true when either an equivalence relation is conflicting or when an implied attribute name is a part of the equivalence relation.
 10. A device comprising: a memory storage comprising instructions; and one or more processors in communication with the memory, wherein the one or more processors execute the instructions to: obtain one or more graph functional dependency (GFD) rules comprising a set of GFD rules; obtain a set of GFDs representative of data; build a canonical graph for the GFD rules; determine that one or more GFD of the sets of GFDs conflicts based on the GFD rules and the canonical graph, and based thereon, determine an error in the set of GFDs.
 11. The device of claim 10 wherein the canonical graph includes an empty graph and wherein the one or more processors execute the instructions to populate the empty graph by an Expand( ) operation prior to determining if any one of the GFDs conflicts iteratively for each rule, and wherein a conflict comprises a literal assigned two distinct constants.
 12. The device of claim 10 wherein the canonical graph comprises a first graph pattern Q6 and a second graph pattern Q7, wherein the canonical graph includes two distinct copies of the first graph pattern, wherein the GFD rules include a first rule: φ₇=Q₆[x, y, z,w](Ø→x.A=0∧y.B=1), a second rule: φ₉=Q₆[x](y.B=1→w.C=1), and third rule: φ₁₀=Q₇[x](w.C=1→x.A=1), wherein x, y, z, and w are vertices, and A, B, and C are attribute names.
 13. The device of claim 12 wherein the one or more processors execute the instructions to: create work units for each graph pattern and graph pattern copy for each GFD rule; coordinate execution of the work units on multiple processors; share results from each processor in response to applying the rule associated with each work unit; and assign remaining work units in response to sharing results to the multiple processors.
 14. The device of claim 10 wherein the one or more processors execute the instructions to: upon determining the set of GFDs does not conflict, receive a new GFD rule; and determine if the set of rules implies the new GFD rule.
 15. The device of claim 14 wherein determining if the set of rules implies the new rule comprises: enforcing GFDs on matches in the canonical graph one by one; and terminating with true when either an equivalence relation is conflicting or when the implied attribute name is a part of the equivalence relation.
 16. The device of claim 15 wherein the one or more processors execute the instructions to: create a priority queue with work units; process the work units on different processors; and share changes with other processors.
 17. A computer-readable media storing computer instructions for detecting errors in data, that when executed by one or more processors cause the one or more processors to perform operations comprising: obtaining a set of GFDs representative of the data; building a canonical graph for the GFD rules; and determining that one or more GFD of the set of GFDs conflict based on the set of GFD rules and the canonical graph and, based thereon, determining an error in the set of GFDs.
 18. The computer-readable media of claim 17 wherein the canonical graph comprises a first graph pattern Q6 and a second graph pattern Q7, wherein the canonical graph includes two distinct copies of the first graph pattern, and wherein the GFD rules include a first rule: φ₇=Q₆ [x, y, z, w](Ø→x.A=0∧y.B=1), a second rule: φ₉=Q₆[x](y.B=1→w.C=1), and third rule: φ₁₀=Q₇[x](w.C=1→x.A=1), wherein x, y, z, and w are vertices, and A, B, and C are attribute names.
 19. The computer-readable media of claim 18 wherein the operations further comprise: creating work units for each graph pattern and copy for each GFD rule; coordinating execution of the work units on multiple processors; sharing results from each processor in response to applying the rule associated with each work unit; and assigning remaining work units in response to sharing results to the multiple processors.
 20. The computer-readable media of claim 19 wherein the operations further comprise: creating a priority queue with the work units; processing the work units on different processors; and sharing changes with other processors. 